package com.xn.app.muying.view;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.view.View;
import android.widget.ImageView;

import java.util.ArrayList;
import java.util.List;

/**
 * 图片扩散动画
 *
 * @author gaoge
 */
public class CircularDiffusionView extends ImageView {
    //对象
    private Context context = null;
    //创建画笔对象
    private Paint paint = null;
    // 透明度集合
    private List<Integer> mAlphas = new ArrayList<>();
    // 扩散圆半径集合
    private List<Integer> mWidths = new ArrayList<>();
    //view控件
    private View view = null;
    //扩散圆宽度   值越小，宽度越大
    private int mDiffuseWidth = 6;
    //最大宽度
    private Integer mMaxWidth = 100;
    //透明度
    private Integer mColor = 100;
    //扩散圈数量
    private Integer mNumber = 5;
    //画圈速度  1000=1秒
    private Integer speedThread = 100;
    //外圈扩散幅度控制
    private Integer amplitude = 1;
    // 是否正在扩散中
    private boolean mIsDiffuse = false;
    //画笔颜色
    private int paintColor = 0x00ffffff;


    //构造方法1
    public CircularDiffusionView(Context context) {
        super(context);
        //方法实现
        init(context);
    }

    //构造方法2
    public CircularDiffusionView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // TODO Auto-generated constructor stub
        //方法实现
        init(context);
    }

    //构造方法3
    public CircularDiffusionView(Context context, AttributeSet attrs) {
        super(context, attrs);
        // TODO Auto-generated constructor stub
        //方法实现
        init(context);
    }

    /**
     * 方法实现
     *
     * @param context 对象
     */
    private void init(Context context) {
        this.context = context;
        //得到画笔对象
        paint = new Paint();
        //防止边缘的锯齿
        paint.setAntiAlias(true);
        //设置圆圈属性
        paint.setStyle(Paint.Style.FILL_AND_STROKE);
    }

    /**
     * 绘制边框
     *
     * @param canvas
     */
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 刷新界面
        if (mIsDiffuse) {
            //得到颜色
            paint.setColor(paintColor);
            for (int i = 0; i < mAlphas.size(); i++) {
                // 设置透明度
                Integer alpha = mAlphas.get(i);
                paint.setAlpha(alpha);
                // 绘制扩散圆
                Integer width = mWidths.get(i);
                canvas.drawCircle(getWidth() / 2, getHeight() / 2, view.getWidth() / 2 + width, paint);

                if (alpha > 0 && width < mMaxWidth) {
                    mAlphas.set(i, alpha - amplitude);
                    mWidths.set(i, width + 1);
                }
            }
            // 判断当扩散圆扩散到指定宽度时添加新扩散圆
            if (mWidths.get(mWidths.size() - 1) == mMaxWidth / mDiffuseWidth) {
                mAlphas.add(mColor);
                mWidths.add(0);
            }
            // 超过5个扩散圆，删除最外层
            if (mWidths.size() >= mNumber) {
                mWidths.remove(0);
                mAlphas.remove(0);
            }
            //控制速度
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(speedThread);
                        loginHandler.sendEmptyMessage(1);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    @SuppressLint("HandlerLeak")
    Handler loginHandler = new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    //刷新画笔
                    invalidate();
                    break;
                default:
                    break;
            }
        }
    };

    /**
     * 开始扩散
     */
    public void start(View view) {
        this.view = view;
        mIsDiffuse = true;
        //设置透明度
        mAlphas.add(mColor);
        //添加初始化扩散圆圈半径
        mWidths.add(0);
        invalidate();
    }

    /**
     * 停止扩散
     */
    public void stop() {
        mIsDiffuse = false;
        mAlphas = new ArrayList<>();
        mWidths = new ArrayList<>();
    }

    /**
     * 设置画笔颜色
     *
     * @param paintColor 颜色码
     */
    public void setPaintColor(int paintColor) {
        this.paintColor = paintColor;
    }

    /**
     * 设置扩散圆宽度
     *
     * @param width 宽度
     */
    public void setDiffuseWidth(int width) {
        this.mDiffuseWidth = width;
    }

    /**
     * 设置圆形总宽度
     *
     * @param width 宽度
     */
    public void setMaxWidth(int width) {
        this.mMaxWidth = width;
    }

    /**
     * 设置透明度
     *
     * @param i 透明色值  0-255
     */
    public void setTransparency(int i) {
        this.mColor = i;
    }

    /**
     * 设置扩散圈圈数
     *
     * @param number
     */
    public void setNumber(int number) {
        this.mNumber = number;
    }

    /**
     * 扩散幅度
     *
     * @param amplitude
     */
    public void setAmplitude(int amplitude) {
        this.amplitude = amplitude;
    }

    /**
     * 控制扩散速度
     *
     * @param m
     */
    public void setSpeedThread(int m) {
        this.speedThread = m;
    }

}
